var token = uni.getStorageSync('token')
// uni.getStorage({     
// 		key:'token',
// 		success(res) {
// 			console.log('获取成功',res.data);
// 		}
// 	})
// console.log(token,'靠靠靠靠靠靠靠')
var url = 'http://api.wonewoo.com/'
// 首页
export function getHomeData(successCallback, errorCallback) {
  uni.request({
    url: url+'api/index/index', 
    method: 'GET',
    success: function(res) {
      if (res.statusCode === 200) {
        let data = res.data;
		console.log('请求成功',data);
        if (data.code === 1) {
          // 请求成功，调用成功回调函数并传递数据
          successCallback(data.data);
        } else {
          // 请求成功，但接口返回的code不为1，表示请求处理失败
          errorCallback(data.msg);
        }
      } else {
        // 请求失败
        errorCallback('请求失败：' + res.statusCode);
		console.log('请求失败',res.statusCode);
      }
    },
    fail: function(err) {
      // 网络请求失败
      errorCallback('网络请求失败：' + err);
    }
  });
}
// 获取收款地址
export function Moteygetaddress(successCallback, errorCallback) {
  uni.request({
    url: url+'api/index/getaddress', 
    method: 'GET',
    success: function(res) {
      if (res.statusCode === 200) {
        let data = res.data;
		console.log('请求成功',data);
        if (data.code === 1) {
          // 请求成功，调用成功回调函数并传递数据
          successCallback(data.data);
        } else {
          // 请求成功，但接口返回的code不为1，表示请求处理失败
          errorCallback(data.msg);
        }
      } else {
        // 请求失败
        errorCallback('请求失败：' + res.statusCode);
		console.log('请求失败',res.statusCode);
      }
    },
    fail: function(err) {
      // 网络请求失败
      errorCallback('网络请求失败：' + err);
    }
  });
}
// 获取密码
export function passwordOne(successCallback, errorCallback) {
  uni.request({
    url: url+'/api/index/password', 
    method: 'GET',
	header:{
		token:uni.getStorageSync('token')
	},
    success: function(res) {
      if (res.statusCode === 200) {
        let data = res.data;
		console.log('请求成功',data);
        if (data.code === 1) {
          // 请求成功，调用成功回调函数并传递数据
          successCallback(data.data);
        } else {
          // 请求成功，但接口返回的code不为1，表示请求处理失败
          errorCallback(data.msg);
        }
      } else {
        // 请求失败
        errorCallback('请求失败：' + res.statusCode);
		console.log('请求失败',res.statusCode);
      }
    },
    fail: function(err) {
      // 网络请求失败
      errorCallback('网络请求失败：' + err);
    }
  });
}
// 提交密码
export function passwordTwo(params,successCallback, errorCallback) {
  uni.request({
    url: url+'api/index/password', 
    method: 'POST',
	header:{
		token:uni.getStorageSync('token')
	},
	data:{
		password:params.password,
	},
    success: function(res) {
      if (res.statusCode === 200) {
        let data = res.data;
		console.log('请求成功',data);
        if (data.code === 1) {
          // 请求成功，调用成功回调函数并传递数据
          successCallback(data.data);
		  
        } else {
          // 请求成功，但接口返回的code不为1，表示请求处理失败
          errorCallback(data.msg);
        }
      } else {
        // 请求失败
        errorCallback('请求失败：' + res.statusCode);
		console.log('请求失败',res.statusCode);
      }
    },
    fail: function(err) {
      // 网络请求失败
      errorCallback('网络请求失败：' + err);
    }
  });
}
// wooK折线图
export function wooKentins(successCallback, errorCallback) {
  uni.request({
    url: url+'api/index/woo_k', 
    method: 'GET',
	header:{
		token:uni.getStorageSync('token')
	},
    success: function(res) {
      if (res.statusCode === 200) {
        let data = res.data;
		console.log('请求成功',data);
        if (data.code === 1) {
          // 请求成功，调用成功回调函数并传递数据
          successCallback(data.data);
        } else {
          // 请求成功，但接口返回的code不为1，表示请求处理失败
          errorCallback(data.msg);
        }
      } else {
        // 请求失败
        errorCallback('请求失败：' + res.statusCode);
		console.log('请求失败',res.statusCode);
      }
    },
    fail: function(err) {
      // 网络请求失败
      errorCallback('网络请求失败：' + err);
    }
  });
}
// 新闻资讯
export function articleData(params,successCallback, errorCallback) {
  uni.request({
    url: url+'api/index/article?id=' + params.id, 
    method: 'GET',
    success: function(res) {
      if (res.statusCode === 200) {
        let data = res.data;
		console.log('请求成功',data);
        if (data.code === 1) {
          // 请求成功，调用成功回调函数并传递数据
          successCallback(data.data);
        } else {
          // 请求成功，但接口返回的code不为1，表示请求处理失败
          errorCallback(data.msg);
        }
      } else {
        // 请求失败
        errorCallback('请求失败：' + res.statusCode);
		console.log('请求失败',res.statusCode);
      }
    },
    fail: function(err) {
      // 网络请求失败
      errorCallback('网络请求失败：' + err);
    }
  });
}
// 获取提现金额
export function withdrawalGet(successCallback, errorCallback) {
  uni.request({
    url: url+'api/index/withdrawal', 
    method: 'GET',
	header:{
		token:uni.getStorageSync('token')
	},
    success: function(res) {
      if (res.statusCode === 200) {
        let data = res.data;
		console.log('请求成功',data);
        if (data.code === 1) {
          // 请求成功，调用成功回调函数并传递数据
          successCallback(data.data);
        } else {
          // 请求成功，但接口返回的code不为1，表示请求处理失败
          errorCallback(data.msg);
        }
      } else {
        // 请求失败
        errorCallback('请求失败：' + res.statusCode);
		console.log('请求失败',res.statusCode);
      }
    },
    fail: function(err) {
      // 网络请求失败
      errorCallback('网络请求失败：' + err);
    }
  });
}
// 提现
export function withdrawalPost(params,successCallback, errorCallback) {
  uni.request({
    url: url+'api/index/withdrawal', 
    method: 'POST',
	header:{
		token:uni.getStorageSync('token')
	},
	data:{
		usdt:params.usdt,
		password:params.password,
	},
    success: function(res) {
      if (res.statusCode === 200) {
        let data = res.data;
		console.log('请求成功',data);
        if (data.code === 1) {
          // 请求成功，调用成功回调函数并传递数据
          successCallback(data.data);
		  
        } else {
          // 请求成功，但接口返回的code不为1，表示请求处理失败
          errorCallback(data.msg);
		  uni.showToast({
		  	 title: data.msg, // 提示内容为请求返回的msg
		  	icon: 'error'
		  })
        }
      } else {
        // 请求失败
		uni.showToast({
			 title: data.msg, // 提示内容为请求返回的msg
			icon: 'error'
		})
        errorCallback('请求失败：' + res.statusCode);
		console.log('请求失败',res.statusCode);
      }
    },
    fail: function(err) {
      // 网络请求失败
      errorCallback('网络请求失败：' + err);
    }
  });
}

// 充值回调接口
export function Recharge(params,successCallback, errorCallback) {
  uni.request({
    url: url+'api/index/recharge', 
    method: 'POST',
	header:{
		token:uni.getStorageSync('token')
	},
	data:{
		// account:params.account,
		// password:params.password,
		hash:params.hash,
	},
    success: function(res) {
      if (res.statusCode === 200) {
        let data = res.data;
		console.log('请求成功',data);
        if (data.code === 1) {
          // 请求成功，调用成功回调函数并传递数据
          successCallback(data.data);
		  
        } else {
          // 请求成功，但接口返回的code不为1，表示请求处理失败
          errorCallback(data.msg);
        }
      } else {
        // 请求失败
        errorCallback('请求失败：' + res.statusCode);
		console.log('请求失败',res.statusCode);
      }
    },
    fail: function(err) {
      // 网络请求失败
      errorCallback('网络请求失败：' + err);
    }
  });
}

// 转大数
export function zhuanShu(params,successCallback, errorCallback) {
  uni.request({
    url: url+'api/index/zhuan', 
    method: 'POST',
	header:{
		token:uni.getStorageSync('token')
	},
	data:{
		usdt:params.usdt,
	},
    success: function(res) {
      if (res.statusCode === 200) {
        let data = res.data;
		console.log('请求成功',data);
        if (data.code === 1) {
          // 请求成功，调用成功回调函数并传递数据
          successCallback(data.data);
		  
        } else {
          // 请求成功，但接口返回的code不为1，表示请求处理失败
          errorCallback(data.msg);
        }
      } else {
        // 请求失败
        errorCallback('请求失败：' + res.statusCode);
		console.log('请求失败',res.statusCode);
      }
    },
    fail: function(err) {
      // 网络请求失败
      errorCallback('网络请求失败：' + err);
    }
  });
}

// 登录
// api/user/login
export function getLogin(params,successCallback, errorCallback) {
  uni.request({
    url: url+'api/index/login', 
    method: 'POST',
	header:{
		token:uni.getStorageSync('token')
	},
	data:{
		// account:params.account,
		// password:params.password,
		url:params.url,
	},
    success: function(res) {
      if (res.statusCode === 200) {
        let data = res.data;
		console.log('请求成功',data);
        if (data.code === 1) {
          // 请求成功，调用成功回调函数并传递数据
          successCallback(data.data);
		  
        } else {
          // 请求成功，但接口返回的code不为1，表示请求处理失败
          errorCallback(data.msg);
        }
      } else {
        // 请求失败
        errorCallback('请求失败：' + res.statusCode);
		console.log('请求失败',res.statusCode);
      }
    },
    fail: function(err) {
      // 网络请求失败
      errorCallback('网络请求失败：' + err);
    }
  });
}
// WONE的交易记录
export function WoneLog(params,successCallback, errorCallback) {
  uni.request({
    url: url+'api/index/wone_log', 
    method: 'GET',
	header:{
		token:uni.getStorageSync('token')
	},
	data:{
		all:params.all,
		page:params.page
	},
    success: function(res) {
      if (res.statusCode === 200) {
        let data = res.data;
		console.log('请求成功',data);
        if (data.code === 1) {
          // 请求成功，调用成功回调函数并传递数据
          successCallback(data.data);
        } else {
          // 请求成功，但接口返回的code不为1，表示请求处理失败
          errorCallback(data.msg);
        }
      } else {
        // 请求失败
        errorCallback('请求失败：' + res.statusCode);
		console.log('请求失败',res.statusCode);
      }
    },
    fail: function(err) {
      // 网络请求失败
      errorCallback('网络请求失败：' + err);
    }
  });
}


// 钱包
export function getMoney(successCallback, errorCallback) {
  uni.request({
    url: url+'api/index/money', 
    method: 'GET',
	header:{
		token:uni.getStorageSync('token')
	},
	data:{
	
	},
    success: function(res) {
      if (res.statusCode === 200) {
        let data = res.data;
		console.log('请求成功',data);
        if (data.code === 1) {
          // 请求成功，调用成功回调函数并传递数据
          successCallback(data.data);
        } else {
          // 请求成功，但接口返回的code不为1，表示请求处理失败
          errorCallback(data.msg);
        }
      } else {
        // 请求失败
        errorCallback('请求失败：' + res.statusCode);
		console.log('请求失败',res.statusCode);
      }
    },
    fail: function(err) {
      // 网络请求失败
      errorCallback('网络请求失败：' + err);
    }
  });
}

// 钱包详情
export function getBonus(params,successCallback, errorCallback) {
  uni.request({
    url: url+'api/index/bonus', 
    method: 'GET',
	header:{
		token:uni.getStorageSync('token')
	},
	data:{
		type:params.type,
		page:params.page
	},
    success: function(res) {
      if (res.statusCode === 200) {
        let data = res.data;
		console.log('请求成功',data);
        if (data.code === 1) {
          // 请求成功，调用成功回调函数并传递数据
          successCallback(data.data);
        } else {
          // 请求成功，但接口返回的code不为1，表示请求处理失败
          errorCallback(data.msg);
        }
      } else {
        // 请求失败
        errorCallback('请求失败：' + res.statusCode);
		console.log('请求失败',res.statusCode);
      }
    },
    fail: function(err) {
      // 网络请求失败
      errorCallback('网络请求失败：' + err);
    }
  });
}

// 五倍专区转换准备页
export function getWealth(successCallback, errorCallback) {
  uni.request({
    url: url+'api/index/wealth', 
    method: 'GET',
	header:{
		token:uni.getStorageSync('token')
	},
	data:{
	
	},
    success: function(res) {
      if (res.statusCode === 200) {
        let data = res.data;
		console.log('请求成功',data);
        if (data.code === 1) {
          // 请求成功，调用成功回调函数并传递数据
          successCallback(data.data);
        } else {
          // 请求成功，但接口返回的code不为1，表示请求处理失败
          errorCallback(data.msg);
        }
      } else {
        // 请求失败
        errorCallback('请求失败：' + res.statusCode);
		console.log('请求失败',res.statusCode);
      }
    },
    fail: function(err) {
      // 网络请求失败
      errorCallback('网络请求失败：' + err);
    }
  });
}

// 兑换五倍专区的商品确认操作
export function getExchange(params,successCallback, errorCallback) {
  uni.request({
    url: url+'api/index/exchange', 
    method: 'POST',
	header:{
		token:uni.getStorageSync('token')
	},
	data:{
		usdt:params.usdt,
		password:params.password,
	},
    success: function(res) {
      if (res.statusCode === 200) {
        let data = res.data;
		console.log('请求成功',data);
        if (data.code === 1) {
          // 请求成功，调用成功回调函数并传递数据
          successCallback(data);
        } else {
          // 请求成功，但接口返回的code不为1，表示请求处理失败
          errorCallback(data.msg);
		  uni.showToast({
		  	 title: data.msg, // 提示内容为请求返回的msg
		  	icon: 'error'
		  })
        }
      } else {
        // 请求失败
        errorCallback('请求失败：' + res.statusCode);
		console.log('请求失败',res.statusCode);
      }
    },
    fail: function(err) {
      // 网络请求失败
      errorCallback('网络请求失败：' + err);
    }
  });
}

// 配额确认
export function getPayWone(params,successCallback, errorCallback) {
  uni.request({
    url: url+'api/index/pay_wone', 
    method: 'POST',
	header:{
		token:uni.getStorageSync('token')
	},
	data:{
		usdt:params.usdt,
		password:params.password
	},
    success: function(res) {
      if (res.statusCode === 200) {
        let data = res.data;
		console.log('请求成功',data);
        if (data.code === 1) {
          // 请求成功，调用成功回调函数并传递数据
          successCallback(data);
        } else {
          // 请求成功，但接口返回的code不为1，表示请求处理失败
          errorCallback(data.msg);
		  uni.showToast({
		  	 title: data.msg, // 提示内容为请求返回的msg
		  	icon: 'error'
		  })
        }
      } else {
        // 请求失败
        errorCallback('请求失败：' + res.statusCode);
		console.log('请求失败',res.statusCode);
      }
    },
    fail: function(err) {
      // 网络请求失败
      errorCallback('网络请求失败：' + err);
    }
  });
}

// 配额准备页
export function getPay(successCallback, errorCallback) {
  uni.request({
    url: url+'api/index/pay_wone', 
    method: 'GET',
	header:{
		token:uni.getStorageSync('token')
	},
	data:{
	
	},
    success: function(res) {
      if (res.statusCode === 200) {
        let data = res.data;
		console.log('请求成功',data);
        if (data.code === 1) {
          // 请求成功，调用成功回调函数并传递数据
          successCallback(data.data);
        } else {
          // 请求成功，但接口返回的code不为1，表示请求处理失败
          errorCallback(data.msg);
        }
      } else {
        // 请求失败
        errorCallback('请求失败：' + res.statusCode);
		console.log('请求失败',res.statusCode);
      }
    },
    fail: function(err) {
      // 网络请求失败
      errorCallback('网络请求失败：' + err);
    }
  });
}

// 购买节点准备页
export function getPayNode(successCallback, errorCallback) {
  uni.request({
    url: url+'api/index/pey_node',
    method: 'GET',
	header:{
		token:uni.getStorageSync('token')
	},
	data:{
	
	},
    success: function(res) {
      if (res.statusCode === 200) {
        let data = res.data;
		console.log('请求成功',data);
        if (data.code === 1) {
          // 请求成功，调用成功回调函数并传递数据
          successCallback(data.data);
        } else {
          // 请求成功，但接口返回的code不为1，表示请求处理失败
          errorCallback(data.msg);
		  
        }
      } else {
        // 请求失败
        errorCallback('请求失败：' + res.statusCode);
		console.log('请求失败',res.statusCode);
      }
    },
    fail: function(err) {
      // 网络请求失败
      errorCallback('网络请求失败：' + err);
    }
  });
}

// 购买节点会员
export function getPayNodeBtn(params,successCallback, errorCallback) {
  uni.request({
    url: url+'api/index/pey_node',
    method: 'POST',
	header:{
		token:uni.getStorageSync('token')
	},
	data:{
		node:params.node,
		password:params.password
	},
    success: function(res) {
      if (res.statusCode === 200) {
        let data = res.data;
		console.log('请求成功',data);
        if (data.code === 1) {
          // 请求成功，调用成功回调函数并传递数据
          successCallback(data.data);
        } else {
          // 请求成功，但接口返回的code不为1，表示请求处理失败
          errorCallback(data.msg);
		  uni.showToast({
		  	 title: data.msg, // 提示内容为请求返回的msg
		  	icon: 'error'
		  })
        }
      } else {
        // 请求失败
        errorCallback('请求失败：' + res.statusCode);
		console.log('请求失败',res.statusCode);
      }
    },
    fail: function(err) {
      // 网络请求失败
      errorCallback('网络请求失败：' + err);
    }
  });
}

// 节点会员
export function getMember(successCallback, errorCallback) {
  uni.request({
    url: url+'api/index/member_node',
    method: 'GET',
	header:{
		token:uni.getStorageSync('token')
	},
	data:{
		
	},
    success: function(res) {
      if (res.statusCode === 200) {
        let data = res.data;
		console.log('请求成功',data);
        if (data.code === 1) {
          // 请求成功，调用成功回调函数并传递数据
          successCallback(data.data);
        } else {
          // 请求成功，但接口返回的code不为1，表示请求处理失败
          errorCallback(data.msg);
		  // uni.showToast({
		  // 	 title: data.msg, // 提示内容为请求返回的msg
		  // 	icon: 'error'
		  // })
        }
      } else {
        // 请求失败
        errorCallback('请求失败：' + res.statusCode);
		console.log('请求失败',res.statusCode);
      }
    },
    fail: function(err) {
      // 网络请求失败
      errorCallback('网络请求失败：' + err);
    }
  });
}


// 我的团队
export function getMyteam(params,successCallback, errorCallback) {
  uni.request({
    url: url+'api/index/myteam',
    method: 'GET',
	header:{
		token:uni.getStorageSync('token')
	},
	data:{
		page:params.page
	},
    success: function(res) {
      if (res.statusCode === 200) {
        let data = res.data;
		console.log('请求成功',data);
        if (data.code === 1) {
          // 请求成功，调用成功回调函数并传递数据
          successCallback(data.data);
        } else {
          // 请求成功，但接口返回的code不为1，表示请求处理失败
          errorCallback(data.msg);
        }
      } else {
        // 请求失败
        errorCallback('请求失败：' + res.statusCode);
		console.log('请求失败',res.statusCode);
      }
    },
    fail: function(err) {
      // 网络请求失败
      errorCallback('网络请求失败：' + err);
    }
  });
}

// 我的钱包交易明细
export function getUsdt(params,successCallback, errorCallback) {
  uni.request({
    url: url+'api/index/usdt',
    method: 'GET',
	header:{
		token:uni.getStorageSync('token')
	},
	data:{
		all:params.all,
		page:params.page,
	},
    success: function(res) {
      if (res.statusCode === 200) {
        let data = res.data;
		console.log('请求成功',data);
        if (data.code === 1) {
          // 请求成功，调用成功回调函数并传递数据
          successCallback(data.data);
        } else {
          // 请求成功，但接口返回的code不为1，表示请求处理失败
          errorCallback(data.msg);
        }
      } else {
        // 请求失败
        errorCallback('请求失败：' + res.statusCode);
		console.log('请求失败',res.statusCode);
      }
    },
    fail: function(err) {
      // 网络请求失败
      errorCallback('网络请求失败：' + err);
    }
  });
}

// 获取闪兑参数
export function getFlash(successCallback, errorCallback) {
  uni.request({
    url: url+'api/index/flash',
    method: 'GET',
	header:{
		token:uni.getStorageSync('token')
	},
	data:{
		
	},
    success: function(res) {
      if (res.statusCode === 200) {
        let data = res.data;
		console.log('请求成功',data);
        if (data.code === 1) {
          // 请求成功，调用成功回调函数并传递数据
          successCallback(data.data);
        } else {
          // 请求成功，但接口返回的code不为1，表示请求处理失败
          errorCallback(data.msg);
        }
      } else {
        // 请求失败
        errorCallback('请求失败：' + res.statusCode);
		console.log('请求失败',res.statusCode);
      }
    },
    fail: function(err) {
      // 网络请求失败
      errorCallback('网络请求失败：' + err);
    }
  });
}

// 闪兑wone操作
export function getFlashBtn(params,successCallback, errorCallback) {
  uni.request({
    url: url+'api/index/flash',
    method: 'POST',
	header:{
		token:uni.getStorageSync('token')
	},
	data:{
		wone:params.wone,
		password:params.password,
	},
    success: function(res) {
      if (res.statusCode === 200) {
        let data = res.data;
		console.log('请求成功',data);
        if (data.code === 1) {
          // 请求成功，调用成功回调函数并传递数据
          successCallback(data.data);
        } else {
          // 请求成功，但接口返回的code不为1，表示请求处理失败
          errorCallback(data.msg);
		  uni.showToast({
		  	 title: data.msg, // 提示内容为请求返回的msg
		  	icon: 'error'
		  })
        }
      } else {
        // 请求失败
        errorCallback('请求失败：' + res.statusCode);
		console.log('请求失败',res.statusCode);
      }
    },
    fail: function(err) {
      // 网络请求失败
      errorCallback('网络请求失败：' + err);
    }
  });
}

// 质押明细
export function getPledge(params,successCallback, errorCallback) {
  uni.request({
    url: url+'api/index/pledge',
    method: 'POST',
	header:{
		token:uni.getStorageSync('token')
	},
	data:{
		page:params.page
	},
    success: function(res) {
      if (res.statusCode === 200) {
        let data = res.data;
		console.log('请求成功',data);
        if (data.code === 1) {
          // 请求成功，调用成功回调函数并传递数据
          successCallback(data.data);
        } else {
          // 请求成功，但接口返回的code不为1，表示请求处理失败
          errorCallback(data.msg);
        }
      } else {
        // 请求失败
        errorCallback('请求失败：' + res.statusCode);
		console.log('请求失败',res.statusCode);
      }
    },
    fail: function(err) {
      // 网络请求失败
      errorCallback('网络请求失败：' + err);
    }
  });
}


// 绑定上级推荐人
export function getBind(params,successCallback, errorCallback) {
  uni.request({
    url: url+'api/index/bind',
    method: 'POST',
	header:{
		token:uni.getStorageSync('token')
	},
	data:{
		url:params.url
	},
    success: function(res) {
      if (res.statusCode === 200) {
        let data = res.data;
		console.log('请求成功',data);
        if (data.code === 1) {
          // 请求成功，调用成功回调函数并传递数据
          successCallback(data.data);
        } else {
          // 请求成功，但接口返回的code不为1，表示请求处理失败
          errorCallback(data.msg);
		  uni.showToast({
		  	 title: data.msg, // 提示内容为请求返回的msg
		  	icon: 'error'
		  })
        }
      } else {
        // 请求失败
        errorCallback('请求失败：' + res.statusCode);
		console.log('请求失败',res.statusCode);
      }
    },
    fail: function(err) {
      // 网络请求失败
      errorCallback('网络请求失败：' + err);
    }
  });
}
//获取推荐人ID
export function getUser(successCallback, errorCallback) {
  uni.request({
    url: url+'api/index/get_user',
    method: 'GET',
	header:{
		token:uni.getStorageSync('token')
	},
	data:{
		
	},
    success: function(res) {
		console.log(res,'datafghj');
      // if (res.statusCode === 200) {
        let data = res.data;
		console.log('请求成功',data);
        if (data.code == 1) {
          // 请求成功，调用成功回调函数并传递数据
          successCallback(data);
        } else {
          // 请求成功，但接口返回的code不为1，表示请求处理失败
          errorCallback(data.msg);
		  uni.showToast({
		  	 title: data.msg, // 提示内容为请求返回的msg
		  	icon: 'error'
		  })
        }
      // } else {
        // 请求失败
        // errorCallback('请求失败：' + res.statusCode);
		// console.log('请求失败',res.statusCode);
      // }
    },
    fail: function(err) {
      // 网络请求失败
      errorCallback('网络请求失败：' + err);
    }
  });
}

//获取自己资料
export function getMYsix(successCallback, errorCallback) {
  uni.request({
    url: url+'api/index/get_my',
    method: 'GET',
	header:{
		token:uni.getStorageSync('token')
	},
	data:{
		
	},
    success: function(res) {
      // if (res.statusCode === 200) {
        let data = res.data;
		// console.log('请求成功',data);
        if (data.code == 1) {
          // 请求成功，调用成功回调函数并传递数据
          successCallback(data);
        } else {
          // 请求成功，但接口返回的code不为1，表示请求处理失败
          errorCallback(data.msg);
        }
      // } else {
        // 请求失败
        // errorCallback('请求失败：' + res.statusCode);
		// console.log('请求失败',res.statusCode);
      // }
    },
    fail: function(err) {
      // 网络请求失败
      errorCallback('网络请求失败：' + err);
    }
  });
}


